---
id: custom-connectors
sidebar_label: Custom Connectors
title: Custom Connectors
description: Deploy and Run a Rasa Chat Bot on a custom chat interface
---

You can also implement your own custom channel. You can
use the `rasa.core.channels.rest.RestInput` class as a template.
The methods you need to implement are `blueprint` and `name`. The method
needs to create a sanic blueprint that can be attached to a sanic server.

This allows you to add REST endpoints to the server that the external
messaging service can call to deliver messages.

Your blueprint should have at least the two routes: `health` on `/`,
and `receive` on the HTTP route `/webhook`.

The `name` method defines the url prefix. For example, if your component is
named `myio`, the webhook you can use to attach the external service is
`http://<host>:<port>/webhooks/myio/webhook`, replacing 
the host and port with the appropriate values from your running Rasa X or Rasa Open Source server.

You can `POST` messages to your custom connector at the url 
`http://<host>:<port>/webhooks/myio/webhook` using the following format:

```json
{
  "sender": "test_user",  // sender ID of the user sending the message
  "message": "Hi there!",
  "metadata": {}  // optional, any extra info you want to add for processing in NLU or custom actions
}
```

If you need to use extra information from your front end in your custom
actions, you can add this information in the `metadata` dict of your user
message. This information will accompany the user message through the rasa
server into the action server when applicable, where you can find it stored in
the `tracker`. Message metadata will not directly affect NLU classification
or action prediction. If you want to change the way metadata is extracted for an
existing channel, you can overwrite the function `get_metadata`. The return value
of this method will be passed to the `UserMessage`.

In your implementation of the `receive` endpoint, you will need
to call `on_new_message(UserMessage(text, output, sender_id))`.
This will tell Rasa Core to handle this user message. The `output`
is an output channel implementing the `OutputChannel` class. You can
either implement the methods for your particular chat channel (e.g. there
are methods to send text and images) or you can use the
`CollectingOutputChannel` to collect the bot responses Core
creates while the bot is processing your messages and return
them as part of your endpoint response. This is the way the `RestInput`
channel is implemented. For examples on how to create and use your own output
channel, take a look at the implementations of the other
output channels, e.g. the `SlackBot` in `rasa.core.channels.slack`.

To use a custom channel, you need to supply a credentials configuration file
`credentials.yml` with the command line argument `--credentials`.
This credentials file has to contain the module path of your custom channel and
any required configuration parameters. For example, this could look like:

```yaml-rasa
mypackage.MyIO:
  username: "user_name"
  another_parameter: "some value"
```

Here is an example implementation for an input channel that receives the messages,
hands them over to Rasa Core, collects the bot utterances, and returns
these bot utterances as the json response to the webhook call that
posted the message to the channel:

```python (docs/sources/rasa/core/channels/rest.py)
```
